﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<ctype.h>
#include<assert.h>
#include<stdbool.h>

//#define MAX 1000
//#define reg register //为 register这个关键字，创建⼀个简短的名字 
//#define do_forever for(;;) //⽤更形象的符号来替换⼀种实现 
//#define CASE break;case //在写case语句的时候⾃动把 break写上。 
//// 如果定义的 stuff过⻓，可以分成⼏⾏写，除了最后⼀⾏外，每⾏的后⾯都加⼀个反斜杠(续⾏符)。
//#define DEBUG_PRINT printf("file:%s\tline:%d\t \
// date:%s\ttime:%s\n" ,\
// __FILE__,__LINE__ , \
// __DATE__,__TIME__ ) 

//#define定义宏
//下⾯是宏的申明⽅式：
//#define name( parament-list ) stuff
//参数列表的左括号必须与name紧邻，如果两者之间有任何空⽩存在，参数列表就会被解释为stuff的⼀部分。
//所以⽤于对数值表达式进⾏求值的宏定义都应该⽤这种⽅式加上括号，避免在使⽤宏时由于参数中的操作符或邻近操作符之间不可预料的相互作⽤。

//带有副作⽤的宏参数
//当宏参数在宏的定义中出现超过⼀次的时候，如果参数带有副作⽤，那么你在使⽤这个宏的时候就可能出现危险，导致不可预测的后果。副作⽤就是表达式求值的时候出现的永久性效果。

//宏替换的规则
//在程序中扩展#define定义符号和宏时，需要涉及⼏个步骤。
//1. 在调⽤宏时，⾸先对参数进⾏检查，看看是否包含任何由#define定义的符号。如果是，它们⾸先被替换。
//2. 替换⽂本随后被插⼊到程序中原来⽂本的位置。对于宏，参数名被他们的值所替换。
//3. 最后，再次对结果⽂件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程
//注意：
//1. 宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
//2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

//宏函数的对⽐
//宏通常被应⽤于执⾏简单的运算。
//那为什么不⽤函数来完成这个任务？
//原因有⼆：
//1. ⽤于调⽤函数和从函数返回的代码可能⽐实际执⾏这个⼩型计算⼯作所需要的时间更多。所以宏⽐函数在程序的规模和速度⽅⾯更胜⼀筹。
//2. 更为重要的是函数的参数必须声明为特定的类型。所以函数只能在类型合适的表达式上使⽤。反之
//这个宏怎可以适⽤于整形、⻓整型、浮点型等可以⽤于 > 来⽐较的类型。宏的参数是类型⽆关的。和函数相⽐宏的劣势：
//1. 每次使⽤宏的时候，⼀份宏定义的代码将插⼊到程序中。除⾮宏⽐较短，否则可能⼤幅度增加程序的⻓度。
//2. 宏是没法调试的。
//3. 宏由于类型⽆关，也就不够严谨。
//4. 宏可能会带来运算符优先级的问题，导致程容易出现错。
//宏有时候可以做函数做不到的事情。⽐如：宏的参数可以出现类型，但是函数做不到
//#define MALLOC(num, type)\
// (type )malloc(num sizeof(type))
//...
////使⽤ 
//MALLOC(10, int);//类型作为参数 
//
////预处理器替换之后： 
//(int*)malloc(10 sizeof(int));

//写一个宏，求2个数的较大值
#define MAX(x,y) ((x)>(y)?(x):(y))

//int main()
//{
//	int a = 3;
//	int b = 5;
//	int m = MAX(a, b);
//	printf("%d\n", m);
//	return 0;
//}


//int main()
//{
//	int a = 3;
//	int b = 5;
//	int m = MAX(a++, b++);
//	printf("m=%d\n", m);//6
//	printf("a=%d\n", a);//4
//	printf("b=%d\n", b);//7
//	return 0;
//}

//#运算符
//#运算符将宏的⼀个参数转换为字符串字⾯量。它仅允许出现在带参数的宏的替换列表中。
//#运算符所执⾏的操作可以理解为”字符串化“。


//#define Print(n,format) printf("the value of "#n" is "format"\n",n)
//int main()
//{
//	int a = 1;
//	Print(a,"%d");
//	int b = 20;
//	Print(b, "%d");
//	float f = 5.6f;
//	Print(f, "%f");
//	return 0;
//}


//##运算符
//## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的⽂本⽚段创建标识符。 ## 被称为记号粘合
//这样的连接必须产⽣⼀个合法的标识符。否则其结果就是未定义的
//宏定义 
//#define GENERIC_MAX(type) \
//type type##_max(type x, type y)\
//{ \
// return (x>y?x:y); \
//}
//GENERIC_MAX(int) //替换到宏体内后int##_max ⽣成了新的符号 int_max做函数名 
//GENERIC_MAX(float) //替换到宏体内后float##_max ⽣成了新的符号 float_max做函数名 
//
//int main()
//{
//	//调⽤函数 
//	int m = int_max(2, 3);
//	printf("%d\n", m);//3
//	float fm = float_max(3.5f, 4.5f);
//	printf("%f\n", fm);//4.500000
//	return 0;
//}


//命名约定
//⼀般来讲函数的宏的使⽤语法很相似。所以语⾔本⾝没法帮我们区分⼆者。
//那我们平时的⼀个习惯是：
//把宏名全部⼤写
//函数名不要全部⼤写

//#undef
//这条指令⽤于移除⼀个宏定义。
//#undef NAME
//如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除

//命令⾏定义
//许多C的编译器提供了⼀种能⼒，允许在命令⾏中定义符号。⽤于启动编译过程。
//例如：当我们根据同⼀个源⽂件要编译出⼀个程序的不同版本的时候，这个特性有点⽤处。（假定某
//个程序中声明了⼀个某个⻓度的数组，如果机器内存有限，我们需要⼀个很⼩的数组，但是另外⼀个
//机器内存⼤些，我们需要⼀个数组能够⼤些)。
//#include <stdio.h>
//int main()
//{
//	int array[ARRAY_SIZE];
//	int i = 0;
//	for (i = 0; i < ARRAY_SIZE; i++)
//	{
//		array[i] = i;
//	}
//	for (i = 0; i < ARRAY_SIZE; i++)
//	{
//		printf("%d ", array[i]);
//	}
//	printf("\n");
//	return 0;
//}


//offsetof---宏 计算结构体成员相较于结构体起始位置的偏移量

//条件编译
//在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很⽅便的。因为我们有条件编译指令。

//#define __DEBUG__
//int main()
//{
//	int i = 0;
//	int arr[10] = { 0 };
//	for (i = 0; i < 10; i++)
//	{
//		arr[i] = i;
//#ifdef __DEBUG__
//		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。  
//#endif //__DEBUG__
//	}
//	return 0;
//}

//头⽂件被包含的⽅式
//本地⽂件包含  #include "filename"
//查找策略：先在源⽂件所在⽬录下查找，如果该头⽂件未找到，编译器就像查找库函数头⽂件⼀样在标准位置查找头⽂件。如果找不到就提⽰编译错误

//库⽂件包含  #include <filename.h>
//查找头⽂件直接去标准路径下去查找，如果找不到就提⽰编译错误。
//这样是不是可以说，对于库⽂件也可以使⽤ “” 的形式包含？
//答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库⽂件还是本地⽂件了

//嵌套⽂件包含
//我们已经知道， #include 指令可以使另外⼀个⽂件被编译。就像它实际出现于 #include 指令的地⽅⼀样。
//这种替换的⽅式很简单：预处理器先删除这条指令，并⽤包含⽂件的内容替换。
//⼀个头⽂件被包含10次，那就实际被编译10次，如果重复包含，对编译的压⼒就⽐较⼤。
//如果直接这样写，test.c⽂件中将test.h包含5次，那么test.h⽂件的内容将会被拷⻉5份在test.c中。
//如果test.h⽂件⽐较⼤，这样预处理后代码量会剧增。如果⼯程⽐较⼤，有公共使⽤的头⽂件，被⼤家
//都能使⽤，⼜不做任何的处理，那么后果真的不堪设想。
//如何解决头⽂件被重复引⼊的问题？答案：条件编译。
//每个头⽂件的开头写：
//#ifndef __TEST_H__
//#define __TEST_H__
//头⽂件的内容 
//#endif //__TEST_H__
//#pragma once
//就可以避免头⽂件的重复引⼊。
//推荐《⾼质量C / C++编程指南》中附录的考试试卷（很重要）。
//笔试题：
//1. 头⽂件中的ifndef / define / endif是⼲什么⽤的 ?   可以避免头⽂件的重复引⼊
//2. #include<filename.h>和#include  查找次数

//其他预处理指令
//#error
//#pragma
//#line
//...
//不做介绍，⾃⼰去了解。
//#pragma pack()在结构体部分介绍
//参考《C语⾔深度解剖》学习















